/*
 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.swing;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.colorchooser.*;
import javax.swing.plaf.ColorChooserUI;
import javax.accessibility.*;

import sun.swing.SwingUtilities2;


/**
 * <code>JColorChooser</code> provides a pane of controls designed to allow a user to manipulate and
 * select a color. For information about using color choosers, see <a
 * href="https://docs.oracle.com/javase/tutorial/uiswing/components/colorchooser.html">How to Use
 * Color Choosers</a>, a section in <em>The Java Tutorial</em>.
 *
 * <p>
 *
 * This class provides three levels of API: <ol> <li>A static convenience method which shows a modal
 * color-chooser dialog and returns the color selected by the user. <li>A static convenience method
 * for creating a color-chooser dialog where <code>ActionListeners</code> can be specified to be
 * invoked when the user presses one of the dialog buttons. <li>The ability to create instances of
 * <code>JColorChooser</code> panes directly (within any container). <code>PropertyChange</code>
 * listeners can be added to detect when the current "color" property changes. </ol> <p>
 * <strong>Warning:</strong> Swing is not thread safe. For more information see <a
 * href="package-summary.html#threading">Swing's Threading Policy</a>. <p> <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with future Swing releases. The current
 * serialization support is appropriate for short term storage or RMI between applications running
 * the same version of Swing.  As of 1.4, support for long term storage of all JavaBeans&trade; has
 * been added to the <code>java.beans</code> package. Please see {@link java.beans.XMLEncoder}.
 *
 * @author James Gosling
 * @author Amy Fowler
 * @author Steve Wilson
 * @beaninfo attribute: isContainer false description: A component that supports selecting a Color.
 */
public class JColorChooser extends JComponent implements Accessible {

  /**
   * @see #getUIClassID
   * @see #readObject
   */
  private static final String uiClassID = "ColorChooserUI";

  private ColorSelectionModel selectionModel;

  private JComponent previewPanel = ColorChooserComponentFactory.getPreviewPanel();

  private AbstractColorChooserPanel[] chooserPanels = new AbstractColorChooserPanel[0];

  private boolean dragEnabled;

  /**
   * The selection model property name.
   */
  public static final String SELECTION_MODEL_PROPERTY = "selectionModel";

  /**
   * The preview panel property name.
   */
  public static final String PREVIEW_PANEL_PROPERTY = "previewPanel";

  /**
   * The chooserPanel array property name.
   */
  public static final String CHOOSER_PANELS_PROPERTY = "chooserPanels";


  /**
   * Shows a modal color-chooser dialog and blocks until the
   * dialog is hidden.  If the user presses the "OK" button, then
   * this method hides/disposes the dialog and returns the selected color.
   * If the user presses the "Cancel" button or closes the dialog without
   * pressing "OK", then this method hides/disposes the dialog and returns
   * <code>null</code>.
   *
   * @param component the parent <code>Component</code> for the dialog
   * @param title the String containing the dialog's title
   * @param initialColor the initial Color set when the color-chooser is shown
   * @return the selected color or <code>null</code> if the user opted out
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true.
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public static Color showDialog(Component component,
      String title, Color initialColor) throws HeadlessException {

    final JColorChooser pane = new JColorChooser(initialColor != null ?
        initialColor : Color.white);

    ColorTracker ok = new ColorTracker(pane);
    JDialog dialog = createDialog(component, title, true, pane, ok, null);

    dialog.addComponentListener(new ColorChooserDialog.DisposeOnClose());

    dialog.show(); // blocks until user brings dialog down...

    return ok.getColor();
  }


  /**
   * Creates and returns a new dialog containing the specified
   * <code>ColorChooser</code> pane along with "OK", "Cancel", and "Reset"
   * buttons. If the "OK" or "Cancel" buttons are pressed, the dialog is
   * automatically hidden (but not disposed).  If the "Reset"
   * button is pressed, the color-chooser's color will be reset to the
   * color which was set the last time <code>show</code> was invoked on the
   * dialog and the dialog will remain showing.
   *
   * @param c the parent component for the dialog
   * @param title the title for the dialog
   * @param modal a boolean. When true, the remainder of the program is inactive until the dialog is
   * closed.
   * @param chooserPane the color-chooser to be placed inside the dialog
   * @param okListener the ActionListener invoked when "OK" is pressed
   * @param cancelListener the ActionListener invoked when "Cancel" is pressed
   * @return a new dialog containing the color-chooser pane
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true.
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public static JDialog createDialog(Component c, String title, boolean modal,
      JColorChooser chooserPane, ActionListener okListener,
      ActionListener cancelListener) throws HeadlessException {

    Window window = JOptionPane.getWindowForComponent(c);
    ColorChooserDialog dialog;
    if (window instanceof Frame) {
      dialog = new ColorChooserDialog((Frame) window, title, modal, c, chooserPane,
          okListener, cancelListener);
    } else {
      dialog = new ColorChooserDialog((Dialog) window, title, modal, c, chooserPane,
          okListener, cancelListener);
    }
    dialog.getAccessibleContext().setAccessibleDescription(title);
    return dialog;
  }

  /**
   * Creates a color chooser pane with an initial color of white.
   */
  public JColorChooser() {
    this(Color.white);
  }

  /**
   * Creates a color chooser pane with the specified initial color.
   *
   * @param initialColor the initial color set in the chooser
   */
  public JColorChooser(Color initialColor) {
    this(new DefaultColorSelectionModel(initialColor));

  }

  /**
   * Creates a color chooser pane with the specified
   * <code>ColorSelectionModel</code>.
   *
   * @param model the <code>ColorSelectionModel</code> to be used
   */
  public JColorChooser(ColorSelectionModel model) {
    selectionModel = model;
    updateUI();
    dragEnabled = false;
  }

  /**
   * Returns the L&amp;F object that renders this component.
   *
   * @return the <code>ColorChooserUI</code> object that renders this component
   */
  public ColorChooserUI getUI() {
    return (ColorChooserUI) ui;
  }

  /**
   * Sets the L&amp;F object that renders this component.
   *
   * @param ui the <code>ColorChooserUI</code> L&amp;F object
   * @beaninfo bound: true hidden: true description: The UI object that implements the color
   * chooser's LookAndFeel.
   * @see UIDefaults#getUI
   */
  public void setUI(ColorChooserUI ui) {
    super.setUI(ui);
  }

  /**
   * Notification from the <code>UIManager</code> that the L&amp;F has changed.
   * Replaces the current UI object with the latest version from the
   * <code>UIManager</code>.
   *
   * @see JComponent#updateUI
   */
  public void updateUI() {
    setUI((ColorChooserUI) UIManager.getUI(this));
  }

  /**
   * Returns the name of the L&amp;F class that renders this component.
   *
   * @return the string "ColorChooserUI"
   * @see JComponent#getUIClassID
   * @see UIDefaults#getUI
   */
  public String getUIClassID() {
    return uiClassID;
  }

  /**
   * Gets the current color value from the color chooser.
   * By default, this delegates to the model.
   *
   * @return the current color value of the color chooser
   */
  public Color getColor() {
    return selectionModel.getSelectedColor();
  }

  /**
   * Sets the current color of the color chooser to the specified color.
   * The <code>ColorSelectionModel</code> will fire a <code>ChangeEvent</code>
   *
   * @param color the color to be set in the color chooser
   * @beaninfo bound: false hidden: false description: The current color the chooser is to display.
   * @see JComponent#addPropertyChangeListener
   */
  public void setColor(Color color) {
    selectionModel.setSelectedColor(color);

  }

  /**
   * Sets the current color of the color chooser to the
   * specified RGB color.  Note that the values of red, green,
   * and blue should be between the numbers 0 and 255, inclusive.
   *
   * @param r an int specifying the amount of Red
   * @param g an int specifying the amount of Green
   * @param b an int specifying the amount of Blue
   * @throws IllegalArgumentException if r,g,b values are out of range
   * @see java.awt.Color
   */
  public void setColor(int r, int g, int b) {
    setColor(new Color(r, g, b));
  }

  /**
   * Sets the current color of the color chooser to the
   * specified color.
   *
   * @param c an integer value that sets the current color in the chooser where the low-order 8 bits
   * specify the Blue value, the next 8 bits specify the Green value, and the 8 bits above that
   * specify the Red value.
   */
  public void setColor(int c) {
    setColor((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF);
  }

  /**
   * Sets the <code>dragEnabled</code> property,
   * which must be <code>true</code> to enable
   * automatic drag handling (the first part of drag and drop)
   * on this component.
   * The <code>transferHandler</code> property needs to be set
   * to a non-<code>null</code> value for the drag to do
   * anything.  The default value of the <code>dragEnabled</code>
   * property
   * is <code>false</code>.
   *
   * <p>
   *
   * When automatic drag handling is enabled,
   * most look and feels begin a drag-and-drop operation
   * when the user presses the mouse button over the preview panel.
   * Some look and feels might not support automatic drag and drop;
   * they will ignore this property.  You can work around such
   * look and feels by modifying the component
   * to directly call the <code>exportAsDrag</code> method of a
   * <code>TransferHandler</code>.
   *
   * @param b the value to set the <code>dragEnabled</code> property to
   * @throws HeadlessException if <code>b</code> is <code>true</code> and
   * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>
   * @beaninfo description: Determines whether automatic drag handling is enabled. bound: false
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see #getDragEnabled
   * @see #setTransferHandler
   * @see TransferHandler
   * @since 1.4
   */
  public void setDragEnabled(boolean b) {
    if (b && GraphicsEnvironment.isHeadless()) {
      throw new HeadlessException();
    }
    dragEnabled = b;
  }

  /**
   * Gets the value of the <code>dragEnabled</code> property.
   *
   * @return the value of the <code>dragEnabled</code> property
   * @see #setDragEnabled
   * @since 1.4
   */
  public boolean getDragEnabled() {
    return dragEnabled;
  }

  /**
   * Sets the current preview panel.
   * This will fire a <code>PropertyChangeEvent</code> for the property
   * named "previewPanel".
   *
   * @param preview the <code>JComponent</code> which displays the current color
   * @beaninfo bound: true hidden: true description: The UI component which displays the current
   * color.
   * @see JComponent#addPropertyChangeListener
   */
  public void setPreviewPanel(JComponent preview) {

    if (previewPanel != preview) {
      JComponent oldPreview = previewPanel;
      previewPanel = preview;
      firePropertyChange(JColorChooser.PREVIEW_PANEL_PROPERTY, oldPreview, preview);
    }
  }

  /**
   * Returns the preview panel that shows a chosen color.
   *
   * @return a <code>JComponent</code> object -- the preview panel
   */
  public JComponent getPreviewPanel() {
    return previewPanel;
  }

  /**
   * Adds a color chooser panel to the color chooser.
   *
   * @param panel the <code>AbstractColorChooserPanel</code> to be added
   */
  public void addChooserPanel(AbstractColorChooserPanel panel) {
    AbstractColorChooserPanel[] oldPanels = getChooserPanels();
    AbstractColorChooserPanel[] newPanels = new AbstractColorChooserPanel[oldPanels.length + 1];
    System.arraycopy(oldPanels, 0, newPanels, 0, oldPanels.length);
    newPanels[newPanels.length - 1] = panel;
    setChooserPanels(newPanels);
  }

  /**
   * Removes the Color Panel specified.
   *
   * @param panel a string that specifies the panel to be removed
   * @return the color panel
   * @throws IllegalArgumentException if panel is not in list of known chooser panels
   */
  public AbstractColorChooserPanel removeChooserPanel(AbstractColorChooserPanel panel) {

    int containedAt = -1;

    for (int i = 0; i < chooserPanels.length; i++) {
      if (chooserPanels[i] == panel) {
        containedAt = i;
        break;
      }
    }
    if (containedAt == -1) {
      throw new IllegalArgumentException("chooser panel not in this chooser");
    }

    AbstractColorChooserPanel[] newArray = new AbstractColorChooserPanel[chooserPanels.length - 1];

    if (containedAt == chooserPanels.length - 1) {  // at end
      System.arraycopy(chooserPanels, 0, newArray, 0, newArray.length);
    } else if (containedAt == 0) {  // at start
      System.arraycopy(chooserPanels, 1, newArray, 0, newArray.length);
    } else {  // in middle
      System.arraycopy(chooserPanels, 0, newArray, 0, containedAt);
      System.arraycopy(chooserPanels, containedAt + 1,
          newArray, containedAt, (chooserPanels.length - containedAt - 1));
    }

    setChooserPanels(newArray);

    return panel;
  }


  /**
   * Specifies the Color Panels used to choose a color value.
   *
   * @param panels an array of <code>AbstractColorChooserPanel</code> objects
   * @beaninfo bound: true hidden: true description: An array of different chooser types.
   */
  public void setChooserPanels(AbstractColorChooserPanel[] panels) {
    AbstractColorChooserPanel[] oldValue = chooserPanels;
    chooserPanels = panels;
    firePropertyChange(CHOOSER_PANELS_PROPERTY, oldValue, panels);
  }

  /**
   * Returns the specified color panels.
   *
   * @return an array of <code>AbstractColorChooserPanel</code> objects
   */
  public AbstractColorChooserPanel[] getChooserPanels() {
    return chooserPanels;
  }

  /**
   * Returns the data model that handles color selections.
   *
   * @return a <code>ColorSelectionModel</code> object
   */
  public ColorSelectionModel getSelectionModel() {
    return selectionModel;
  }


  /**
   * Sets the model containing the selected color.
   *
   * @param newModel the new <code>ColorSelectionModel</code> object
   * @beaninfo bound: true hidden: true description: The model which contains the currently selected
   * color.
   */
  public void setSelectionModel(ColorSelectionModel newModel) {
    ColorSelectionModel oldModel = selectionModel;
    selectionModel = newModel;
    firePropertyChange(JColorChooser.SELECTION_MODEL_PROPERTY, oldModel, newModel);
  }


  /**
   * See <code>readObject</code> and <code>writeObject</code> in
   * <code>JComponent</code> for more
   * information about serialization in Swing.
   */
  private void writeObject(ObjectOutputStream s) throws IOException {
    s.defaultWriteObject();
    if (getUIClassID().equals(uiClassID)) {
      byte count = JComponent.getWriteObjCounter(this);
      JComponent.setWriteObjCounter(this, --count);
      if (count == 0 && ui != null) {
        ui.installUI(this);
      }
    }
  }


  /**
   * Returns a string representation of this <code>JColorChooser</code>.
   * This method
   * is intended to be used only for debugging purposes, and the
   * content and format of the returned string may vary between
   * implementations. The returned string may be empty but may not
   * be <code>null</code>.
   *
   * @return a string representation of this <code>JColorChooser</code>
   */
  protected String paramString() {
    StringBuffer chooserPanelsString = new StringBuffer("");
    for (int i = 0; i < chooserPanels.length; i++) {
      chooserPanelsString.append("[" + chooserPanels[i].toString()
          + "]");
    }
    String previewPanelString = (previewPanel != null ?
        previewPanel.toString() : "");

    return super.paramString() +
        ",chooserPanels=" + chooserPanelsString.toString() +
        ",previewPanel=" + previewPanelString;
  }

/////////////////
// Accessibility support
////////////////

  protected AccessibleContext accessibleContext = null;

  /**
   * Gets the AccessibleContext associated with this JColorChooser.
   * For color choosers, the AccessibleContext takes the form of an
   * AccessibleJColorChooser.
   * A new AccessibleJColorChooser instance is created if necessary.
   *
   * @return an AccessibleJColorChooser that serves as the AccessibleContext of this JColorChooser
   */
  public AccessibleContext getAccessibleContext() {
    if (accessibleContext == null) {
      accessibleContext = new AccessibleJColorChooser();
    }
    return accessibleContext;
  }

  /**
   * This class implements accessibility support for the
   * <code>JColorChooser</code> class.  It provides an implementation of the
   * Java Accessibility API appropriate to color chooser user-interface
   * elements.
   */
  protected class AccessibleJColorChooser extends AccessibleJComponent {

    /**
     * Get the role of this object.
     *
     * @return an instance of AccessibleRole describing the role of the object
     * @see AccessibleRole
     */
    public AccessibleRole getAccessibleRole() {
      return AccessibleRole.COLOR_CHOOSER;
    }

  } // inner class AccessibleJColorChooser
}


/*
 * Class which builds a color chooser dialog consisting of
 * a JColorChooser with "Ok", "Cancel", and "Reset" buttons.
 *
 * Note: This needs to be fixed to deal with localization!
 */
class ColorChooserDialog extends JDialog {

  private Color initialColor;
  private JColorChooser chooserPane;
  private JButton cancelButton;

  public ColorChooserDialog(Dialog owner, String title, boolean modal,
      Component c, JColorChooser chooserPane,
      ActionListener okListener, ActionListener cancelListener)
      throws HeadlessException {
    super(owner, title, modal);
    initColorChooserDialog(c, chooserPane, okListener, cancelListener);
  }

  public ColorChooserDialog(Frame owner, String title, boolean modal,
      Component c, JColorChooser chooserPane,
      ActionListener okListener, ActionListener cancelListener)
      throws HeadlessException {
    super(owner, title, modal);
    initColorChooserDialog(c, chooserPane, okListener, cancelListener);
  }

  protected void initColorChooserDialog(Component c, JColorChooser chooserPane,
      ActionListener okListener, ActionListener cancelListener) {
    //setResizable(false);

    this.chooserPane = chooserPane;

    Locale locale = getLocale();
    String okString = UIManager.getString("ColorChooser.okText", locale);
    String cancelString = UIManager.getString("ColorChooser.cancelText", locale);
    String resetString = UIManager.getString("ColorChooser.resetText", locale);

    Container contentPane = getContentPane();
    contentPane.setLayout(new BorderLayout());
    contentPane.add(chooserPane, BorderLayout.CENTER);

        /*
         * Create Lower button panel
         */
    JPanel buttonPane = new JPanel();
    buttonPane.setLayout(new FlowLayout(FlowLayout.CENTER));
    JButton okButton = new JButton(okString);
    getRootPane().setDefaultButton(okButton);
    okButton.getAccessibleContext().setAccessibleDescription(okString);
    okButton.setActionCommand("OK");
    okButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        hide();
      }
    });
    if (okListener != null) {
      okButton.addActionListener(okListener);
    }
    buttonPane.add(okButton);

    cancelButton = new JButton(cancelString);
    cancelButton.getAccessibleContext().setAccessibleDescription(cancelString);

    // The following few lines are used to register esc to close the dialog
    Action cancelKeyAction = new AbstractAction() {
      public void actionPerformed(ActionEvent e) {
        ((AbstractButton) e.getSource()).fireActionPerformed(e);
      }
    };
    KeyStroke cancelKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
    InputMap inputMap = cancelButton.getInputMap(JComponent.
        WHEN_IN_FOCUSED_WINDOW);
    ActionMap actionMap = cancelButton.getActionMap();
    if (inputMap != null && actionMap != null) {
      inputMap.put(cancelKeyStroke, "cancel");
      actionMap.put("cancel", cancelKeyAction);
    }
    // end esc handling

    cancelButton.setActionCommand("cancel");
    cancelButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        hide();
      }
    });
    if (cancelListener != null) {
      cancelButton.addActionListener(cancelListener);
    }
    buttonPane.add(cancelButton);

    JButton resetButton = new JButton(resetString);
    resetButton.getAccessibleContext().setAccessibleDescription(resetString);
    resetButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        reset();
      }
    });
    int mnemonic = SwingUtilities2.getUIDefaultsInt("ColorChooser.resetMnemonic", locale, -1);
    if (mnemonic != -1) {
      resetButton.setMnemonic(mnemonic);
    }
    buttonPane.add(resetButton);
    contentPane.add(buttonPane, BorderLayout.SOUTH);

    if (JDialog.isDefaultLookAndFeelDecorated()) {
      boolean supportsWindowDecorations =
          UIManager.getLookAndFeel().getSupportsWindowDecorations();
      if (supportsWindowDecorations) {
        getRootPane().setWindowDecorationStyle(JRootPane.COLOR_CHOOSER_DIALOG);
      }
    }
    applyComponentOrientation(((c == null) ? getRootPane() : c).getComponentOrientation());

    pack();
    setLocationRelativeTo(c);

    this.addWindowListener(new Closer());
  }

  public void show() {
    initialColor = chooserPane.getColor();
    super.show();
  }

  public void reset() {
    chooserPane.setColor(initialColor);
  }

  class Closer extends WindowAdapter implements Serializable {

    public void windowClosing(WindowEvent e) {
      cancelButton.doClick(0);
      Window w = e.getWindow();
      w.hide();
    }
  }

  static class DisposeOnClose extends ComponentAdapter implements Serializable {

    public void componentHidden(ComponentEvent e) {
      Window w = (Window) e.getComponent();
      w.dispose();
    }
  }

}

class ColorTracker implements ActionListener, Serializable {

  JColorChooser chooser;
  Color color;

  public ColorTracker(JColorChooser c) {
    chooser = c;
  }

  public void actionPerformed(ActionEvent e) {
    color = chooser.getColor();
  }

  public Color getColor() {
    return color;
  }
}
